home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet internetowy / Przegladarki internetowe / Mozilla Seamonkey 1.0.5 pl / seamonkey-1.0.5.pl-PL.win32.installer.exe / MAIL.XPI / bin / chrome / messenger.jar / content / messenger / msgHdrViewOverlay.js < prev    next >
Encoding:
JavaScript  |  2005-12-22  |  50.9 KB  |  1,420 lines
  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  2.  * ***** BEGIN LICENSE BLOCK *****
  3.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  4.  *
  5.  * The contents of this file are subject to the Mozilla Public License Version
  6.  * 1.1 (the "License"); you may not use this file except in compliance with
  7.  * the License. You may obtain a copy of the License at
  8.  * http://www.mozilla.org/MPL/
  9.  *
  10.  * Software distributed under the License is distributed on an "AS IS" basis,
  11.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12.  * for the specific language governing rights and limitations under the
  13.  * License.
  14.  *
  15.  * The Original Code is Mozilla Communicator client code, released
  16.  * March 31, 1998.
  17.  *
  18.  * The Initial Developer of the Original Code is
  19.  * Netscape Communications Corporation.
  20.  * Portions created by the Initial Developer are Copyright (C) 1998-1999
  21.  * the Initial Developer. All Rights Reserved.
  22.  *
  23.  * Contributor(s):
  24.  *
  25.  * Alternatively, the contents of this file may be used under the terms of
  26.  * either of the GNU General Public License Version 2 or later (the "GPL"),
  27.  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28.  * in which case the provisions of the GPL or the LGPL are applicable instead
  29.  * of those above. If you wish to allow use of your version of this file only
  30.  * under the terms of either the GPL or the LGPL, and not to allow others to
  31.  * use your version of this file under the terms of the MPL, indicate your
  32.  * decision by deleting the provisions above and replace them with the notice
  33.  * and other provisions required by the GPL or the LGPL. If you do not delete
  34.  * the provisions above, a recipient may use your version of this file under
  35.  * the terms of any one of the MPL, the GPL or the LGPL.
  36.  *
  37.  * ***** END LICENSE BLOCK ***** */
  38.  
  39. /* This is where functions related to displaying the headers for a selected message in the
  40.    message pane live. */
  41.  
  42. ////////////////////////////////////////////////////////////////////////////////////
  43. // Warning: if you go to modify any of these JS routines please get a code review from
  44. // mscott@netscape.com. It's critical that the code in here for displaying
  45. // the message headers for a selected message remain as fast as possible. In particular, 
  46. // right now, we only introduce one reflow per message. i.e. if you click on a message in the thread
  47. // pane, we batch up all the changes for displaying the header pane (to, cc, attachements button, etc.) 
  48. // and we make a single pass to display them. It's critical that we maintain this one reflow per message
  49. // view in the message header pane. 
  50. ////////////////////////////////////////////////////////////////////////////////////
  51.  
  52. var msgHeaderParserContractID           = "@mozilla.org/messenger/headerparser;1";
  53. var abAddressCollectorContractID     = "@mozilla.org/addressbook/services/addressCollecter;1";
  54.  
  55. var gViewAllHeaders = false;
  56. var gNumAddressesToShow = 3;
  57. var gShowOrganization = false;
  58. var gShowUserAgent = false;
  59. var gCollectIncoming = false;
  60. var gCollectOutgoing = false;
  61. var gCollectNewsgroup = false;
  62. var gCollapsedHeaderViewMode = false;
  63. var gCollectAddressTimer = null;
  64. var gCollectAddress = null;
  65. var gBuildAttachmentsForCurrentMsg = false;
  66. var gBuildAttachmentPopupForCurrentMsg = true;
  67. var gBuiltExpandedView = false;
  68. var gBuiltCollapsedView = false;
  69. var gOpenLabel;
  70. var gOpenLabelAccesskey;
  71. var gSaveLabel;
  72. var gSaveLabelAccesskey;
  73. var gDetachLabel;
  74. var gDetachLabelAccesskey;
  75. var gDeleteLabel;
  76. var gDeleteLabelAccesskey;
  77. var gMessengerBundle;
  78. var gProfileDirURL;
  79. var gIOService;
  80. var gFileHandler;
  81.  
  82. var msgHeaderParser = Components.classes[msgHeaderParserContractID].getService(Components.interfaces.nsIMsgHeaderParser);
  83. var abAddressCollector = null;
  84.  
  85. // other components may listen to on start header & on end header notifications for each message we display
  86. // to do that you need to add yourself to our gMessageListeners array with object that has two properties:
  87. // onStartHeaders and onEndHeaders.
  88. var gMessageListeners = new Array;
  89.  
  90. // For every possible "view" in the message pane, you need to define the header names you want to
  91. // see in that view. In addition, include information describing how you want that header field to be
  92. // presented. i.e. if it's an email address field, if you want a toggle inserted on the node in case
  93. // of multiple email addresses, etc. We'll then use this static table to dynamically generate header view entries
  94. // which manipulate the UI. 
  95. // When you add a header to one of these view lists you can specify the following properties:
  96. // name: the name of the header. i.e. "to", "subject". This must be in lower case and the name of the
  97. //       header is used to help dynamically generate ids for objects in the document. (REQUIRED)
  98. // useToggle:      true if the values for this header are multiple email addresses and you want a 
  99. //                 a toggle icon to show a short vs. long list (DEFAULT: false)
  100. // useShortView:   (only works on some fields like From). If the field has a long presentation and a
  101. //                 short presentation we'll use the short one. i.e. if you are showing the From field and you
  102. //                 set this to true, we can show just "John Doe" instead of "John Doe <jdoe@netscape.net>".
  103. //                 (DEFAULT: false)
  104. // 
  105. // outputFunction: this is a method which takes a headerEntry (see the definition below) and a header value
  106. //                 This allows you to provide your own methods for actually determining how the header value
  107. //                 is displayed. (DEFAULT: updateHeaderValue which just sets the header value on the text node)
  108.  
  109. // Our first view is the collapsed view. This is very light weight view of the data. We only show a couple
  110. // fields.
  111. var gCollapsedHeaderList = [ {name:"subject", outputFunction:updateHeaderValueInTextNode},
  112.                              {name:"from", useShortView:true, outputFunction:OutputEmailAddresses},
  113.                              {name:"date", outputFunction:updateHeaderValueInTextNode}];
  114.  
  115. // We also have an expanded header view. This shows many of your more common (and useful) headers.
  116. var gExpandedHeaderList = [ {name:"subject"}, 
  117.                             {name:"from", outputFunction:OutputEmailAddresses},
  118.                             {name:"reply-to", outputFunction:OutputEmailAddresses},
  119.                             {name:"date"},
  120.                             {name:"to", useToggle:true, outputFunction:OutputEmailAddresses},
  121.                             {name:"cc", useToggle:true, outputFunction:OutputEmailAddresses},
  122.                             {name:"bcc", useToggle:true, outputFunction:OutputEmailAddresses},
  123.                             {name:"newsgroups", outputFunction:OutputNewsgroups},
  124.                             {name:"followup-to", outputFunction:OutputNewsgroups} ];
  125.  
  126. // Now, for each view the message pane can generate, we need a global table of headerEntries. These
  127. // header entry objects are generated dynamically based on the static date in the header lists (see above)
  128. // and elements we find in the DOM based on properties in the header lists. 
  129. var gCollapsedHeaderView = {};
  130. var gExpandedHeaderView  = {};
  131.  
  132. // currentHeaderData --> this is an array of header name and value pairs for the currently displayed message.
  133. //                       it's purely a data object and has no view information. View information is contained in the view objects.
  134. //                       for a given entry in this array you can ask for:
  135. // .headerName ---> name of the header (i.e. 'to'). Always stored in lower case
  136. // .headerValue --> value of the header "johndoe@netscape.net"
  137. var currentHeaderData = {};
  138.  
  139. // For the currently displayed message, we store all the attachment data. When displaying a particular
  140. // view, it's up to the view layer to extract this attachment data and turn it into something useful.
  141. // For a given entry in the attachments list, you can ask for the following properties:
  142. // .contentType --> the content type of the attachment
  143. // url --> an imap, or mailbox url which can be used to fetch the message
  144. // uri --> an RDF URI which refers to the message containig the attachment
  145. // isExternalAttachment --> boolean flag stating whether the attachment is external or not.
  146. var currentAttachments = new Array();
  147.  
  148. // createHeaderEntry --> our constructor method which creates a header Entry 
  149. // based on an entry in one of the header lists. A header entry is different from a header list.
  150. // a header list just describes how you want a particular header to be presented. The header entry
  151. // actually has knowledge about the DOM and the actual DOM elements associated with the header.
  152. // prefix --> the name of the view (i.e. "collapsed", "expanded")
  153. // headerListInfo --> entry from a header list.
  154. function createHeaderEntry(prefix, headerListInfo)
  155. {
  156.   var partialIDName = prefix + headerListInfo.name;
  157.   this.enclosingBox = document.getElementById(partialIDName + 'Box');
  158.   this.textNode = document.getElementById(partialIDName + 'Value');
  159.   this.isValid = false;
  160.  
  161.   if ("useToggle" in headerListInfo)
  162.   {
  163.     this.useToggle = headerListInfo.useToggle;
  164.     if (this.useToggle) // find the toggle icon in the document
  165.     {
  166.       this.toggleIcon = this.enclosingBox.toggleIcon;
  167.       this.longTextNode = this.enclosingBox.longEmailAddresses;
  168.       this.textNode = this.enclosingBox.emailAddresses;
  169.     }
  170.   }
  171.   else
  172.    this.useToggle = false;
  173.  
  174.   if ("useShortView" in headerListInfo)
  175.   {
  176.     this.useShortView = headerListInfo.useShortView;
  177.     this.enclosingBox.emailAddressNode = this.textNode;
  178.   }
  179.   else
  180.     this.useShortView = false;
  181.  
  182.   if ("outputFunction" in headerListInfo)
  183.     this.outputFunction = headerListInfo.outputFunction;
  184.   else
  185.     this.outputFunction = updateHeaderValue;
  186. }
  187.  
  188. function initializeHeaderViewTables()
  189. {
  190.   // iterate over each header in our header list arrays and create header entries 
  191.   // for each one. These header entries are then stored in the appropriate header table
  192.   var index;
  193.   for (index = 0; index < gCollapsedHeaderList.length; index++)
  194.   {
  195.     gCollapsedHeaderView[gCollapsedHeaderList[index].name] = 
  196.       new createHeaderEntry('collapsed', gCollapsedHeaderList[index]);
  197.   }
  198.  
  199.   for (index = 0; index < gExpandedHeaderList.length; index++)
  200.   {
  201.     var headerName = gExpandedHeaderList[index].name;
  202.     gExpandedHeaderView[headerName] = new createHeaderEntry('expanded', gExpandedHeaderList[index]);
  203.   }
  204.   
  205.   if (gShowOrganization)
  206.   {
  207.     var organizationEntry = {name:"organization", outputFunction:updateHeaderValue};
  208.     gExpandedHeaderView[organizationEntry.name] = new createHeaderEntry('expanded', organizationEntry);
  209.   }
  210.   
  211.   if (gShowUserAgent)
  212.   {
  213.     var userAgentEntry = {name:"user-agent", outputFunction:updateHeaderValue};
  214.     gExpandedHeaderView[userAgentEntry.name] = new createHeaderEntry('expanded', userAgentEntry);
  215.   }
  216. }
  217.  
  218. function OnLoadMsgHeaderPane()
  219. {
  220.   // HACK...force our XBL bindings file to be load before we try to create our first xbl widget....
  221.   // otherwise we have problems.
  222.  
  223.   document.loadBindingDocument('chrome://messenger/content/mailWidgets.xml');
  224.   
  225.   // load any preferences that at are global with regards to 
  226.   // displaying a message...
  227.   gNumAddressesToShow = pref.getIntPref("mailnews.max_header_display_length");
  228.   gCollectIncoming = pref.getBoolPref("mail.collect_email_address_incoming");
  229.   gCollectNewsgroup = pref.getBoolPref("mail.collect_email_address_newsgroup");
  230.   gCollectOutgoing = pref.getBoolPref("mail.collect_email_address_outgoing");
  231.   gShowUserAgent = pref.getBoolPref("mailnews.headers.showUserAgent");
  232.   gShowOrganization = pref.getBoolPref("mailnews.headers.showOrganization");
  233.   initializeHeaderViewTables();
  234.  
  235.   var toggleHeaderView = document.getElementById("msgHeaderView");
  236.   var initialCollapsedSetting = toggleHeaderView.getAttribute("state");
  237.   if (initialCollapsedSetting == "true")
  238.     gCollapsedHeaderViewMode = true;   
  239.  
  240.   // dispatch an event letting any listeners know that we have loaded the message pane
  241.   var event = document.createEvent('Events');
  242.   event.initEvent('messagepane-loaded', false, true);
  243.   var headerViewElement = document.getElementById("msgHeaderView");
  244.   headerViewElement.dispatchEvent(event);
  245. }
  246.  
  247. function OnUnloadMsgHeaderPane()
  248. {
  249.   // dispatch an event letting any listeners know that we have unloaded the message pane
  250.   var event = document.createEvent('Events');
  251.   event.initEvent('messagepane-unloaded', false, true);
  252.   var headerViewElement = document.getElementById("msgHeaderView");
  253.   headerViewElement.dispatchEvent(event);
  254. }
  255.  
  256. // The messageHeaderSink is the class that gets notified of a message's headers as we display the message
  257. // through our mime converter. 
  258.  
  259. var messageHeaderSink = {
  260.     onStartHeaders: function()
  261.     {
  262.       this.mSaveHdr = null;
  263.       // clear out any pending collected address timers...
  264.       if (gCollectAddressTimer)
  265.       {
  266.         gCollectAddress = "";        
  267.         clearTimeout(gCollectAddressTimer);
  268.         gCollectAddressTimer = null;
  269.       }
  270.  
  271.       // every time we start to redisplay a message, check the view all headers pref....
  272.       var showAllHeadersPref = pref.getIntPref("mail.show_headers");
  273.       if (showAllHeadersPref == 2)
  274.       {
  275.         gViewAllHeaders = true;
  276.       }
  277.       else
  278.       {
  279.         if (gViewAllHeaders) // if we currently are in view all header mode, rebuild our header view so we remove most of the header data
  280.         { 
  281.           hideHeaderView(gExpandedHeaderView);
  282.           gExpandedHeaderView = {};
  283.           initializeHeaderViewTables(); 
  284.         }
  285.                 
  286.         gViewAllHeaders = false;
  287.       }
  288.  
  289.       ClearCurrentHeaders();
  290.       gBuiltExpandedView = false;
  291.       gBuiltCollapsedView = false;
  292.       gBuildAttachmentsForCurrentMsg = false;
  293.       gBuildAttachmentPopupForCurrentMsg = true;
  294.       ClearAttachmentList();
  295.       ClearEditMessageButton();
  296.       gMessageNotificationBar.clearMsgNotifications();
  297.  
  298.       for (var index in gMessageListeners)
  299.         gMessageListeners[index].onStartHeaders();
  300.     },
  301.  
  302.     onEndHeaders: function() 
  303.     {
  304.       // WARNING: This is the ONLY routine inside of the message Header Sink that should 
  305.       // trigger a reflow!
  306.       CheckNotify();
  307.       
  308.       ClearHeaderView(gCollapsedHeaderView);
  309.       ClearHeaderView(gExpandedHeaderView);
  310.  
  311.       EnsureSubjectValue(); // make sure there is a subject even if it's empty so we'll show the subject and the twisty
  312.       
  313.       ShowMessageHeaderPane();
  314.       UpdateMessageHeaders();
  315.       if (gIsEditableMsgFolder)
  316.         ShowEditMessageButton();
  317.  
  318.       for (var index in gMessageListeners)
  319.         gMessageListeners[index].onEndHeaders();
  320.     },
  321.  
  322.     processHeaders: function(headerNameEnumerator, headerValueEnumerator, dontCollectAddress)
  323.     {
  324.       this.onStartHeaders(); 
  325.  
  326.       var index = 0;
  327.       while (headerNameEnumerator.hasMore()) 
  328.       {
  329.         var header = new Object;        
  330.         header.headerValue = headerValueEnumerator.getNext();
  331.         header.headerName = headerNameEnumerator.getNext();
  332.  
  333.         // for consistancy sake, let's force all header names to be lower case so
  334.         // we don't have to worry about looking for: Cc and CC, etc.
  335.         var lowerCaseHeaderName = header.headerName.toLowerCase();
  336.  
  337.         // if we have an x-mailer, x-newsreader, or x-mimeole string,
  338.         // put it in the user-agent slot which we know how to handle already.
  339.         if (lowerCaseHeaderName == "x-mailer" ||
  340.             lowerCaseHeaderName == "x-newsreader" ||
  341.             lowerCaseHeaderName == "x-mimeole")
  342.           lowerCaseHeaderName = "user-agent";          
  343.         
  344.         if (this.mDummyMsgHeader)
  345.         {
  346.           if (lowerCaseHeaderName == "from")
  347.             this.mDummyMsgHeader.author = header.headerValue;
  348.           else if (lowerCaseHeaderName == "to")
  349.             this.mDummyMsgHeader.recipients = header.headerValue;
  350.           else if (lowerCaseHeaderName == "cc")
  351.             this.mDummyMsgHeader.ccList = header.headerValue;
  352.           else if (lowerCaseHeaderName == "subject")
  353.             this.mDummyMsgHeader.subject = header.headerValue;
  354.           else if (lowerCaseHeaderName == "reply-to")
  355.             this.mDummyMsgHeader.replyTo = header.headerValue;
  356.           else if (lowerCaseHeaderName == "message-id")
  357.             this.mDummyMsgHeader.messageId = header.headerValue;
  358.  
  359.         }
  360.         // according to RFC 2822, certain headers
  361.         // can occur "unlimited" times
  362.         if (lowerCaseHeaderName in currentHeaderData)
  363.         {
  364.           // sometimes, you can have multiple To or Cc lines....
  365.           // in this case, we want to append these headers into one.
  366.           if (lowerCaseHeaderName == 'to' || lowerCaseHeaderName == 'cc')
  367.             currentHeaderData[lowerCaseHeaderName].headerValue = currentHeaderData[lowerCaseHeaderName].headerValue + ',' + header.headerValue;
  368.           else 
  369.           {  
  370.             // use the index to create a unique header name like:
  371.             // received5, received6, etc
  372.             currentHeaderData[lowerCaseHeaderName + index++] = header;
  373.           }
  374.         }
  375.         else
  376.          currentHeaderData[lowerCaseHeaderName] = header;
  377.  
  378.         if (lowerCaseHeaderName == "from")
  379.         {
  380.           if (header.value) 
  381.           {
  382.             if ((gCollectIncoming && !dontCollectAddress) || 
  383.                 (gCollectNewsgroup && dontCollectAddress))
  384.             {
  385.               if (!abAddressCollector)
  386.                 abAddressCollector = Components.classes[abAddressCollectorContractID].getService(Components.interfaces.nsIAbAddressCollecter);
  387.  
  388.               gCollectAddress = header.headerValue;
  389.               // collect, and add card if doesn't exist, unknown preferred send format
  390.               gCollectAddressTimer = setTimeout('abAddressCollector.collectUnicodeAddress(gCollectAddress, true, Components.interfaces.nsIAbPreferMailFormat.unknown);', 2000);
  391.             }
  392.             else if (gCollectOutgoing) 
  393.             {
  394.               if (!abAddressCollector)
  395.                 abAddressCollector = Components.classes[abAddressCollectorContractID].getService(Components.interfaces.nsIAbAddressCollecter);
  396.  
  397.               // collect, but only update existing cards, unknown preferred send format
  398.               gCollectAddress = header.headerValue;
  399.               gCollectAddressTimer = setTimeout('abAddressCollector.collectUnicodeAddress(gCollectAddress, false, Components.interfaces.nsIAbPreferMailFormat.unknown);', 2000);
  400.             }
  401.           }
  402.         } // if lowerCaseHeaderName == "from"
  403.       } // while we have more headers to parse
  404.  
  405.       this.onEndHeaders();
  406.     },
  407.  
  408.     handleAttachment: function(contentType, url, displayName, uri, isExternalAttachment) 
  409.     {
  410.       // presentation level change....don't show vcards as external attachments in the UI.
  411.       // libmime already renders them inline.
  412.  
  413.       try
  414.       {
  415.         if (!this.mSaveHdr)
  416.           this.mSaveHdr = messenger.msgHdrFromURI(uri);
  417.       }
  418.       catch (ex) {}
  419.       if (contentType == "text/x-vcard")
  420.       {
  421.         var inlineAttachments = pref.getBoolPref("mail.inline_attachments");
  422.         var displayHtmlAs = pref.getIntPref("mailnews.display.html_as");
  423.         if (inlineAttachments && !displayHtmlAs)
  424.           return;
  425.       }
  426.  
  427.       currentAttachments.push (new createNewAttachmentInfo(contentType, url, displayName, uri, isExternalAttachment));
  428.       // if we have an attachment, set the MSG_FLAG_ATTACH flag on the hdr
  429.       // this will cause the "message with attachment" icon to show up
  430.       // in the thread pane
  431.       // we only need to do this on the first attachment
  432.       var numAttachments = currentAttachments.length;
  433.       if (numAttachments == 1) {
  434.         // we also have to enable the File/Attachments menuitem
  435.         var node = document.getElementById("fileAttachmentMenu");
  436.         if (node)
  437.           node.removeAttribute("disabled");
  438.  
  439.         try {
  440.           // convert the uri into a hdr
  441.           this.mSaveHdr.markHasAttachments(true);
  442.         }
  443.         catch (ex) {
  444.           dump("ex = " + ex + "\n");
  445.         }
  446.       }
  447.     },
  448.     
  449.     onEndAllAttachments: function()
  450.     {
  451.       // AddSaveAllAttachmentsMenu();
  452.       if (gCollapsedHeaderViewMode)
  453.         displayAttachmentsForCollapsedView();
  454.       else
  455.         displayAttachmentsForExpandedView();
  456.     },
  457.  
  458.     onEndMsgDownload: function(url)
  459.     {
  460.       // if we don't have any attachments, turn off the attachments flag
  461.       if (!this.mSaveHdr)
  462.       {
  463.         var messageUrl = url.QueryInterface(Components.interfaces.nsIMsgMessageUrl);
  464.         try
  465.         {
  466.           this.mSaveHdr = messenger.msgHdrFromURI(messageUrl.uri);
  467.         }
  468.         catch (ex) {}
  469.  
  470.       }
  471.       if (!currentAttachments.length && this.mSaveHdr)
  472.         this.mSaveHdr.markHasAttachments(false);
  473.       OnMsgParsed(url);
  474.     },
  475.  
  476.     onEndMsgHeaders: function(url)
  477.     { 
  478.       OnMsgLoaded(url);
  479.     },
  480.     
  481.     onMsgHasRemoteContent: function(aMsgHdr)
  482.     {
  483.       gMessageNotificationBar.setRemoteContentMsg(aMsgHdr);
  484.     },
  485.  
  486.     mSecurityInfo  : null,
  487.     mSaveHdr: null,
  488.     getSecurityInfo: function()
  489.     {
  490.       return this.mSecurityInfo;
  491.     },
  492.     setSecurityInfo: function(aSecurityInfo)
  493.     {
  494.       this.mSecurityInfo = aSecurityInfo;
  495.     },
  496.  
  497.     mDummyMsgHeader: null,
  498.  
  499.     getDummyMsgHeader: function()
  500.     {
  501.       if (!this.mDummyMsgHeader)
  502.         this.mDummyMsgHeader = new nsDummyMsgHeader();
  503.       return this.mDummyMsgHeader;
  504.     }
  505. };
  506.  
  507. function EnsureSubjectValue()
  508. {
  509.   if (!('subject' in currentHeaderData))
  510.   {
  511.     var foo = new Object;
  512.     foo.headerValue = "";
  513.     foo.headerName = 'subject';
  514.     currentHeaderData[foo.headerName] = foo;
  515.   } 
  516. }
  517.  
  518. function CheckNotify()
  519. {
  520.   if ("NotifyClearAddresses" in this)
  521.     NotifyClearAddresses();
  522. }
  523.  
  524.  
  525. // flush out any local state being held by a header entry for a given
  526. // table
  527. function ClearHeaderView(headerTable)
  528. {
  529.   for (index in headerTable)
  530.   {
  531.      var headerEntry = headerTable[index];
  532.      if (headerEntry.useToggle)
  533.      {
  534.        headerEntry.enclosingBox.clearEmailAddresses();    
  535.      }
  536.  
  537.      headerEntry.valid = false;
  538.   }
  539. }
  540.  
  541. // make sure that any valid header entry in the table is collapsed
  542. function hideHeaderView(headerTable)
  543. {
  544.   for (index in headerTable)
  545.   {
  546.     headerTable[index].enclosingBox.collapsed = true;
  547.   }
  548. }
  549.  
  550. // make sure that any valid header entry in the table specified is 
  551. // visible
  552. function showHeaderView(headerTable)
  553. {
  554.   var headerEntry;
  555.   for (index in headerTable)
  556.   {
  557.     headerEntry = headerTable[index];
  558.     if (headerEntry.valid)
  559.     {
  560.       headerEntry.enclosingBox.collapsed = false;
  561.     }
  562.     else // if the entry is invalid, always make sure it's collapsed
  563.       headerEntry.enclosingBox.collapsed = true;
  564.   }
  565. }
  566.  
  567. // make sure the appropriate fields within the currently displayed view header mode
  568. // are collapsed or visible...
  569. function updateHeaderViews()
  570. {
  571.   if (gCollapsedHeaderViewMode)
  572.   {
  573.     showHeaderView(gCollapsedHeaderView);
  574.     displayAttachmentsForCollapsedView();
  575.   }
  576.   else
  577.   {
  578.     showHeaderView(gExpandedHeaderView);
  579.     displayAttachmentsForExpandedView();
  580.   }
  581. }
  582.  
  583. function ToggleHeaderView ()
  584. {
  585.   var expandedNode = document.getElementById("expandedHeaderView");
  586.   var collapsedNode = document.getElementById("collapsedHeaderView");
  587.   var toggleHeaderView = document.getElementById("msgHeaderView");
  588.  
  589.   if (gCollapsedHeaderViewMode)
  590.   {          
  591.     gCollapsedHeaderViewMode = false;
  592.     // hide the current view
  593.     hideHeaderView(gCollapsedHeaderView);
  594.     // update the current view
  595.     UpdateMessageHeaders();
  596.     
  597.     // now uncollapse / collapse the right views
  598.     expandedNode.collapsed = false;
  599.     collapsedNode.collapsed = true;
  600.   }
  601.   else
  602.   {
  603.     gCollapsedHeaderViewMode = true;
  604.     // hide the current view
  605.     hideHeaderView(gExpandedHeaderView);
  606.     // update the current view
  607.     UpdateMessageHeaders();
  608.     
  609.     // now uncollapse / collapse the right views
  610.     collapsedNode.collapsed = false;
  611.     expandedNode.collapsed = true;
  612.   }  
  613.  
  614.   if (gCollapsedHeaderViewMode)
  615.     toggleHeaderView.setAttribute("state", "true");
  616.   else
  617.     toggleHeaderView.setAttribute("state", "false");
  618. }
  619.  
  620. // default method for updating a header value into a header entry
  621. function updateHeaderValue(headerEntry, headerValue)
  622. {
  623.   headerEntry.enclosingBox.headerValue = headerValue;
  624. }
  625.  
  626. function updateHeaderValueInTextNode(headerEntry, headerValue)
  627. {
  628.   headerEntry.textNode.value = headerValue;
  629. }
  630.  
  631. function createNewHeaderView(headerName)
  632. {
  633.   var idName = 'expanded' + headerName + 'Box';
  634.   var newHeader = document.createElement("mail-headerfield");
  635.   newHeader.setAttribute('id', idName);
  636.   newHeader.setAttribute('label', currentHeaderData[headerName].headerName + ':');
  637.   // all mail-headerfield elements are keyword related
  638.   newHeader.setAttribute('keywordrelated','true');
  639.   newHeader.collapsed = true;
  640.  
  641.   // this new element needs to be inserted into the view...
  642.   var topViewNode = document.getElementById('expandedHeaders');
  643.  
  644.   topViewNode.appendChild(newHeader);
  645.   
  646.   this.enclosingBox = newHeader
  647.   this.isValid = false;
  648.   this.useToggle = false;
  649.   this.useShortView = false;
  650.   this.outputFunction = updateHeaderValue;
  651. }
  652.  
  653. // UpdateMessageHeaders: Iterate through all the current header data we received from mime for this message
  654. // for each header entry table, see if we have a corresponding entry for that header. i.e. does the particular
  655. // view care about this header value. if it does then call updateHeaderEntry
  656. function UpdateMessageHeaders()
  657. {
  658.   // iterate over each header we received and see if we have a matching entry in each
  659.   // header view table...
  660.  
  661.   for (headerName in currentHeaderData)
  662.   {
  663.     var headerField = currentHeaderData[headerName];
  664.     var headerEntry = null;
  665.  
  666.     if (headerName == "subject")
  667.     {
  668.       try {
  669.         if (gDBView.keyForFirstSelectedMessage == nsMsgKey_None)
  670.         {
  671.           var folder = null;
  672.           if (gCurrentFolderUri)
  673.             folder = RDF.GetResource(gCurrentFolderUri).QueryInterface(Components.interfaces.nsIMsgFolder);
  674.           setTitleFromFolder(folder, headerField.headerValue);
  675.         }
  676.       } catch (ex) {}
  677.     }
  678.     
  679.     if (gCollapsedHeaderViewMode && !gBuiltCollapsedView)
  680.     { 
  681.       if (headerName in gCollapsedHeaderView)
  682.         headerEntry = gCollapsedHeaderView[headerName];
  683.     }
  684.     else if (!gCollapsedHeaderViewMode && !gBuiltExpandedView)
  685.     {
  686.       if (headerName in gExpandedHeaderView)
  687.         headerEntry = gExpandedHeaderView[headerName];
  688.  
  689.       if (!headerEntry && gViewAllHeaders)
  690.       {
  691.         // for view all headers, if we don't have a header field for this value....cheat and create one....then
  692.         // fill in a headerEntry
  693.         gExpandedHeaderView[headerName] = new createNewHeaderView(headerName);
  694.         headerEntry = gExpandedHeaderView[headerName];
  695.       }
  696.     } // if we are in expanded view....
  697.  
  698.     if (headerEntry)
  699.     {  
  700.       headerEntry.outputFunction(headerEntry, headerField.headerValue);
  701.       headerEntry.valid = true;    
  702.     }
  703.   }
  704.  
  705.   if (gCollapsedHeaderViewMode)
  706.    gBuiltCollapsedView = true;
  707.   else
  708.    gBuiltExpandedView = true;
  709.  
  710.   // now update the view to make sure the right elements are visible
  711.   updateHeaderViews();
  712.   
  713.   if ("FinishEmailProcessing" in this)
  714.     FinishEmailProcessing();
  715. }
  716.  
  717. function ClearCurrentHeaders()
  718. {
  719.   currentHeaderData = {};
  720.   currentAttachments = new Array();
  721. }
  722.  
  723. function ShowMessageHeaderPane()
  724. { 
  725.   var node;
  726.   if (gCollapsedHeaderViewMode)
  727.   {          
  728.     node = document.getElementById("collapsedHeaderView");
  729.     if (node)
  730.       node.collapsed = false;
  731.   }
  732.   else
  733.   {
  734.     node = document.getElementById("expandedHeaderView");
  735.     if (node)
  736.       node.collapsed = false;
  737.   }
  738.  
  739.     /* workaround for 39655 */
  740.   if (gFolderJustSwitched) 
  741.   {
  742.     var el = document.getElementById("msgHeaderView");
  743.     el.setAttribute("style", el.getAttribute("style"));
  744.     gFolderJustSwitched = false;    
  745.   }
  746. }
  747.  
  748. function HideMessageHeaderPane()
  749. {
  750.   var node = document.getElementById("collapsedHeaderView");
  751.   if (node)
  752.     node.collapsed = true;
  753.  
  754.   node = document.getElementById("expandedHeaderView");
  755.   if (node)
  756.     node.collapsed = true;
  757.  
  758.   // we also have to disable the File/Attachments menuitem
  759.   node = document.getElementById("fileAttachmentMenu");
  760.   if (node)
  761.     node.setAttribute("disabled", "true");
  762. }
  763.  
  764. function OutputNewsgroups(headerEntry, headerValue)
  765. { 
  766.   headerValue = headerValue.replace(/,/g,", ");
  767.   updateHeaderValue(headerEntry, headerValue);
  768. }
  769.  
  770. // OutputEmailAddresses --> knows how to take a comma separated list of email addresses,
  771. // extracts them one by one, linkifying each email address into a mailto url. 
  772. // Then we add the link'ified email address to the parentDiv passed in.
  773. // 
  774. // defaultParentDiv --> the div to add the link-ified email addresses into. 
  775. // emailAddresses --> comma separated list of the addresses for this header field
  776. // includeShortLongToggle --> true if you want to include the ability to toggle between short/long
  777. // address views for this header field. If true, then pass in a another div which is the div the long
  778. // view will be added too...
  779. // useShortView --> if true, we'll only generate the Name of the email address field instead of
  780. //                        showing the name + the email address.
  781.  
  782. function OutputEmailAddresses(headerEntry, emailAddresses)
  783. {
  784.   if ( !emailAddresses ) return;
  785.  
  786.   if (msgHeaderParser)
  787.   {
  788.     var addresses = {};
  789.     var fullNames = {};
  790.     var names = {};
  791.     var numAddresses =  0;
  792.  
  793.     numAddresses = msgHeaderParser.parseHeadersWithArray(emailAddresses, addresses, names, fullNames);
  794.     var index = 0;
  795.     while (index < numAddresses)
  796.     {
  797.       // if we want to include short/long toggle views and we have a long view, always add it.
  798.       // if we aren't including a short/long view OR if we are and we haven't parsed enough
  799.       // addresses to reach the cutoff valve yet then add it to the default (short) div.
  800.       if (headerEntry.useToggle)
  801.       {
  802.         var address = {};
  803.         address.emailAddress = addresses.value[index];
  804.         address.fullAddress = fullNames.value[index];
  805.         address.displayName = names.value[index];
  806.         headerEntry.enclosingBox.addAddressView(address);
  807.       }
  808.       else
  809.       {
  810.         updateEmailAddressNode(headerEntry.enclosingBox.emailAddressNode, addresses.value[index], 
  811.                                fullNames.value[index], names.value[index], headerEntry.useShortView);
  812.       }
  813.  
  814.       if (headerEntry.enclosingBox.getAttribute("id") == "expandedfromBox") {
  815.         setFromBuddyIcon(addresses.value[index]);
  816.       }
  817.  
  818.       index++;
  819.     }
  820.     
  821.     if (headerEntry.useToggle)
  822.       headerEntry.enclosingBox.buildViews(gNumAddressesToShow);
  823.   } // if msgheader parser
  824. }
  825.  
  826. function setFromBuddyIcon(email)
  827. {
  828.    var fromBuddyIcon = document.getElementById("fromBuddyIcon");
  829.  
  830.    try {
  831.      // better to cache this?
  832.      var myScreenName = pref.getCharPref("aim.session.screenname");
  833.  
  834.      if (!abAddressCollector)
  835.        abAddressCollector = Components.classes[abAddressCollectorContractID].getService(Components.interfaces.nsIAbAddressCollecter);
  836.  
  837.      var card = abAddressCollector.getCardFromAttribute("PrimaryEmail", email);
  838.  
  839.      if (myScreenName && card && card.aimScreenName) {
  840.        if (!gIOService) {
  841.          // lazily create these globals
  842.          gIOService = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
  843.          gFileHandler = gIOService.getProtocolHandler("file").QueryInterface(Components.interfaces.nsIFileProtocolHandler);
  844.          
  845.          var dirService = Components.classes["@mozilla.org/file/directory_service;1"]
  846.              .getService(Components.interfaces.nsIProperties);
  847.          var profileDir = dirService.get("ProfD", Components.interfaces.nsIFile);
  848.          gProfileDirURL = gIOService.newFileURI(profileDir);
  849.        }
  850.  
  851.        // if we did have a buddy icon on disk for this screenname, this would be the file url spec for it
  852.        var iconURLStr = gProfileDirURL.spec + "/NIM/" + myScreenName + "/picture/" + card.aimScreenName + ".gif";
  853.  
  854.        // check if the file exists
  855.        // is this a perf hit?  (how expensive is stat()?)
  856.        var iconFile = gFileHandler.getFileFromURLSpec(iconURLStr);
  857.        if (iconFile.exists()) {
  858.          fromBuddyIcon.setAttribute("src", iconURLStr);
  859.          return;
  860.        }
  861.      }
  862.    }
  863.    catch (ex) {
  864.      // can get here if no screenname
  865.      //dump("ex = " + ex + "\n");
  866.    }
  867.    fromBuddyIcon.setAttribute("src", "");
  868. }
  869.  
  870. function updateEmailAddressNode(emailAddressNode, emailAddress, fullAddress, displayName, useShortView)
  871. {
  872.   if (useShortView && displayName) {
  873.     emailAddressNode.setAttribute("label", displayName);
  874.     emailAddressNode.setAttribute("tooltiptext", emailAddress);
  875.   } else {
  876.     emailAddressNode.setAttribute("label", fullAddress || displayName);
  877.     emailAddressNode.removeAttribute("tooltiptext");
  878.   }
  879.   emailAddressNode.setTextAttribute("emailAddress", emailAddress);
  880.   emailAddressNode.setTextAttribute("fullAddress", fullAddress);  
  881.   emailAddressNode.setTextAttribute("displayName", displayName);  
  882.   
  883.   if ("AddExtraAddressProcessing" in this)
  884.     AddExtraAddressProcessing(emailAddress, emailAddressNode);
  885. }
  886.  
  887. // createnewAttachmentInfo --> constructor method for creating new attachment object which goes into the
  888. // data attachment array.
  889. function createNewAttachmentInfo(contentType, url, displayName, uri, isExternalAttachment)
  890. {
  891.   this.contentType = contentType;
  892.   this.url = url;
  893.   this.displayName = displayName;
  894.   this.uri = uri;
  895.   this.isExternalAttachment = isExternalAttachment;
  896.   this.attachment = this;
  897. }
  898.  
  899. createNewAttachmentInfo.prototype.saveAttachment = function saveAttachment()
  900. {
  901.   if (this.isExternalAttachment)
  902.     internalSave(this.url, null,
  903.                  this.displayName, null,
  904.                  this.contentType, false,
  905.                  "SaveAttachmentTitle", null, null);
  906.   else
  907.     messenger.saveAttachment(this.contentType, 
  908.                              this.url, 
  909.                              encodeURIComponent(this.displayName), 
  910.                              this.uri,
  911.                              false);
  912. }
  913.  
  914. createNewAttachmentInfo.prototype.openAttachment = function openAttachment()
  915. {
  916.   messenger.openAttachment(this.contentType, 
  917.                            this.url, 
  918.                            encodeURIComponent(this.displayName), 
  919.                            this.uri,
  920.                            this.isExternalAttachment);
  921. }
  922.  
  923. createNewAttachmentInfo.prototype.printAttachment = function printAttachment()
  924. {
  925.   /* we haven't implemented the ability to print attachments yet...
  926.   messenger.printAttachment(this.contentType, 
  927.                             this.url, 
  928.                             encodeURIComponent(this.displayName), 
  929.                             this.uri);
  930.   */
  931. }
  932.  
  933. createNewAttachmentInfo.prototype.deleteAttachment = function deleteAttachment()
  934. {
  935.   messenger.detachAttachment(this.contentType,
  936.                              this.url,
  937.                              encodeURIComponent(this.displayName),
  938.                              this.uri,
  939.                              false);
  940. }
  941.  
  942. createNewAttachmentInfo.prototype.detachAttachment = function detachAttachment()
  943. {
  944.   messenger.detachAttachment(this.contentType,
  945.                              this.url,
  946.                              encodeURIComponent(this.displayName),
  947.                              this.uri,
  948.                              true);
  949. }
  950.  
  951. function CanDetachAttachments()
  952. {
  953.   var uri = GetLoadedMessage();
  954.   return !IsNewsMessage(uri) && (!IsImapMessage(uri) || CheckOnline());
  955. }
  956.  
  957. function onShowAttachmentContextMenu()
  958. {
  959.   // if no attachments are selected, disable the Open and Save...
  960.   var attachmentList = document.getElementById('attachmentList');
  961.   var selectedAttachments = attachmentList.selectedItems;
  962.   var openMenu = document.getElementById('context-openAttachment');
  963.   var saveMenu = document.getElementById('context-saveAttachment');
  964.   var detachMenu = document.getElementById('context-detachAttachment');
  965.   var deleteMenu = document.getElementById('context-deleteAttachment');
  966.   var detachAllMenu = document.getElementById('context-detachAllAttachments');
  967.   var deleteAllMenu = document.getElementById('context-deleteAllAttachments');
  968.   var canDetach = CanDetachAttachments();
  969.   var canOpen = false;
  970.   for (var i = 0; i < selectedAttachments.length && !canOpen; i++)
  971.     canOpen = selectedAttachments[i].attachment.contentType != 'text/x-moz-deleted';
  972.   if (canOpen && selectedAttachments.length == 1)
  973.   {
  974.     openMenu.removeAttribute('disabled');
  975.   }
  976.   else
  977.   {
  978.     openMenu.setAttribute('disabled', true);
  979.   }
  980.   if (canOpen)
  981.   {
  982.     saveMenu.removeAttribute('disabled');
  983.   }
  984.   else
  985.   {
  986.     saveMenu.setAttribute('disabled', true);
  987.   }
  988.   if (canDetach && canOpen)
  989.   {
  990.     detachMenu.removeAttribute('disabled');
  991.     deleteMenu.removeAttribute('disabled');
  992.   }
  993.   else
  994.   {
  995.     detachMenu.setAttribute('disabled', 'true');
  996.     deleteMenu.setAttribute('disabled', 'true');
  997.   }
  998.   if (canDetach)
  999.   {
  1000.     detachAllMenu.removeAttribute('disabled');
  1001.     deleteAllMenu.removeAttribute('disabled');
  1002.   }
  1003.   else
  1004.   {
  1005.     detachAllMenu.setAttribute('disabled', 'true');
  1006.     deleteAllMenu.setAttribute('disabled', 'true');
  1007.   }
  1008. }
  1009.  
  1010. // this is our onclick handler for the attachment list. 
  1011. // A double click in a listitem simulates "opening" the attachment....
  1012. function attachmentListClick(event)
  1013. { 
  1014.     // we only care about button 0 (left click) events
  1015.     if (event.button != 0) return;
  1016.  
  1017.     if (event.detail == 2) // double click
  1018.     {
  1019.       var target = event.target;
  1020.       if (target.localName == "listitem")
  1021.       {
  1022.     target.attachment.openAttachment();
  1023.       }
  1024.     }
  1025. }
  1026.  
  1027. // on command handlers for the attachment list context menu...
  1028. // commandPrefix matches one of our existing functions 
  1029. // (openAttachment, saveAttachment, etc.)
  1030. function handleAttachmentSelection(commandPrefix)
  1031. {
  1032.   var attachmentList = document.getElementById('attachmentList');
  1033.   var selectedAttachments = attachmentList.selectedItems;
  1034.   if (selectedAttachments.length > 1)
  1035.     HandleMultipleAttachments(commandPrefix, selectedAttachments);
  1036.   else
  1037.     selectedAttachments[0].attachment[commandPrefix]();
  1038. }
  1039.  
  1040. function displayAttachmentsForExpandedView()
  1041. {
  1042.   var numAttachments = currentAttachments.length;
  1043.   if (numAttachments > 0 && !gBuildAttachmentsForCurrentMsg)
  1044.   {
  1045.     var attachmentList = document.getElementById('attachmentList');
  1046.  
  1047.     for (index in currentAttachments)
  1048.     {
  1049.       var attachment = currentAttachments[index];
  1050.  
  1051.       // we need to create a listitem to insert the attachment
  1052.       // into the attachment list..
  1053.       var item = attachmentList.appendItem(attachment.displayName,"");
  1054.       item.setAttribute("class", "listitem-iconic attachment-item"); 
  1055.       item.setAttribute("tooltip", "attachmentListTooltip");
  1056.       item.attachment = attachment;
  1057.       item.setAttribute("attachmentUrl", attachment.url);
  1058.       item.setAttribute("attachmentContentType", attachment.contentType);
  1059.       item.setAttribute("attachmentUri", attachment.uri);
  1060.       if (attachment.contentType == "text/x-moz-deleted")
  1061.         item.setAttribute('disabled', 'true');
  1062.       else
  1063.         setApplicationIconForAttachment(attachment, item);
  1064.     } // for each attachment   
  1065.  
  1066.     gBuildAttachmentsForCurrentMsg = true;
  1067.   }
  1068.    
  1069.   var expandedAttachmentBox = document.getElementById('expandedAttachmentBox');
  1070.   expandedAttachmentBox.collapsed = numAttachments <= 0;
  1071. }
  1072.  
  1073. // attachment --> the attachment struct containing all the information on the attachment
  1074. // listitem --> the listitem currently showing the attachment.
  1075. function setApplicationIconForAttachment(attachment, listitem)
  1076. {
  1077.    // generate a moz-icon url for the attachment so we'll show a nice icon next to it.
  1078.    listitem.setAttribute('image', "moz-icon:" + "//" + attachment.displayName + "?size=16&contentType=" + attachment.contentType);
  1079. }
  1080.  
  1081. function displayAttachmentsForCollapsedView()
  1082. {
  1083.   var numAttachments = currentAttachments.length;
  1084.   var attachmentNode = document.getElementById('collapsedAttachmentBox');
  1085.   attachmentNode.collapsed = numAttachments <= 0; // make sure the attachment button is visible
  1086. }
  1087.  
  1088. // Public method called to generate a tooltip over an attachment
  1089. function FillInAttachmentTooltip(cellNode)
  1090. {
  1091.   var attachmentName = cellNode.getAttribute("label");
  1092.   var tooltipNode = document.getElementById("attachmentListTooltip");
  1093.   tooltipNode.setAttribute("label", attachmentName);
  1094.   return true;
  1095. }
  1096.  
  1097. // Public method called when we create the attachments file menu
  1098. function FillAttachmentListPopup(popup)
  1099. {
  1100.   // the FE sometimes call this routine TWICE...I haven't been able to figure out why yet...
  1101.   // protect against it...
  1102.  
  1103.   if (!gBuildAttachmentPopupForCurrentMsg) return; 
  1104.  
  1105.   var attachmentIndex = 0;
  1106.  
  1107.   // otherwise we need to build the attachment view...
  1108.   // First clear out the old view...
  1109.   ClearAttachmentMenu(popup);
  1110.  
  1111.   for (index in currentAttachments)
  1112.   {
  1113.     ++attachmentIndex;
  1114.     addAttachmentToPopup(popup, currentAttachments[index], attachmentIndex);
  1115.   }
  1116.  
  1117.   gBuildAttachmentPopupForCurrentMsg = false;
  1118.  
  1119.   var detachAllMenu = document.getElementById('file-detachAllAttachments');
  1120.   var deleteAllMenu = document.getElementById('file-deleteAllAttachments');
  1121.   if (CanDetachAttachments())
  1122.   {
  1123.     detachAllMenu.removeAttribute('disabled');
  1124.     deleteAllMenu.removeAttribute('disabled');
  1125.   }
  1126.   else
  1127.   {
  1128.     detachAllMenu.setAttribute('disabled', 'true');
  1129.     deleteAllMenu.setAttribute('disabled', 'true');
  1130.   }
  1131. }
  1132.  
  1133. // Public method used to clear the file attachment menu
  1134. function ClearAttachmentMenu(popup) 
  1135. { 
  1136.   if ( popup ) 
  1137.   { 
  1138.      while ( popup.childNodes[0].localName == 'menu' )
  1139.        popup.removeChild(popup.childNodes[0]); 
  1140.   } 
  1141. }
  1142.  
  1143. // Public method used to determine the number of attachments for the currently displayed message...
  1144. function GetNumberOfAttachmentsForDisplayedMessage()
  1145. {
  1146.   return currentAttachments.length;
  1147. }
  1148.  
  1149. // private method used to build up a menu list of attachments
  1150. function addAttachmentToPopup(popup, attachment, attachmentIndex) 
  1151. { 
  1152.   if (popup)
  1153.   { 
  1154.     var item = document.createElement('menu');
  1155.     if ( item ) 
  1156.     {     
  1157.       if (!gMessengerBundle)
  1158.         gMessengerBundle = document.getElementById("bundle_messenger");
  1159.  
  1160.       // insert the item just before the separator
  1161.       item = popup.insertBefore(item, popup.childNodes[attachmentIndex - 1]);
  1162.       item.setAttribute('class', 'menu-iconic attachment-item');
  1163.  
  1164.       var formattedDisplayNameString = gMessengerBundle.getFormattedString("attachmentDisplayNameFormat",
  1165.                                        [attachmentIndex, attachment.displayName]);
  1166.  
  1167.       item.setAttribute('label', formattedDisplayNameString); 
  1168.       item.setAttribute('accesskey', attachmentIndex); 
  1169.       if (attachment.contentType == "text/x-moz-deleted") {
  1170.         item.setAttribute('disabled', 'true');
  1171.         return;
  1172.       }
  1173.       setApplicationIconForAttachment(attachment, item);
  1174.       var canDetach = CanDetachAttachments();
  1175.  
  1176.       var openpopup = document.createElement('menupopup');
  1177.       openpopup = item.appendChild(openpopup);
  1178.  
  1179.       var menuitementry = document.createElement('menuitem');     
  1180.  
  1181.       menuitementry.attachment = attachment;
  1182.       menuitementry.setAttribute('oncommand', 'this.attachment.openAttachment()'); 
  1183.  
  1184.       if (!gDeleteLabel)
  1185.         gDeleteLabel = gMessengerBundle.getString("deleteLabel");
  1186.       if (!gDeleteLabelAccesskey)
  1187.         gDeleteLabelAccesskey = gMessengerBundle.getString("deleteLabelAccesskey");
  1188.       if (!gDetachLabel)
  1189.         gDetachLabel = gMessengerBundle.getString("detachLabel");
  1190.       if (!gDetachLabelAccesskey)
  1191.         gDetachLabelAccesskey = gMessengerBundle.getString("detachLabelAccesskey");
  1192.       if (!gSaveLabel)
  1193.         gSaveLabel = gMessengerBundle.getString("saveLabel");
  1194.       if (!gSaveLabelAccesskey)
  1195.         gSaveLabelAccesskey = gMessengerBundle.getString("saveLabelAccesskey");
  1196.       if (!gOpenLabel)
  1197.         gOpenLabel = gMessengerBundle.getString("openLabel");
  1198.       if (!gOpenLabelAccesskey)
  1199.         gOpenLabelAccesskey = gMessengerBundle.getString("openLabelAccesskey");
  1200.  
  1201.       menuitementry.setAttribute('label', gOpenLabel); 
  1202.       menuitementry.setAttribute('accesskey', gOpenLabelAccesskey); 
  1203.       menuitementry = openpopup.appendChild(menuitementry);
  1204.  
  1205.       menuitementry = document.createElement('menuitem');
  1206.       menuitementry.attachment = attachment;
  1207.       menuitementry.setAttribute('oncommand', 'this.attachment.saveAttachment()'); 
  1208.       menuitementry.setAttribute('label', gSaveLabel); 
  1209.       menuitementry.setAttribute('accesskey', gSaveLabelAccesskey); 
  1210.       menuitementry = openpopup.appendChild(menuitementry);
  1211.  
  1212.       var menuseparator = document.createElement('menuseparator');
  1213.       openpopup.appendChild(menuseparator);
  1214.  
  1215.       menuitementry = document.createElement('menuitem');
  1216.       menuitementry.attachment = attachment;
  1217.       menuitementry.setAttribute('oncommand', 'this.attachment.detachAttachment()'); 
  1218.       menuitementry.setAttribute('label', gDetachLabel); 
  1219.       menuitementry.setAttribute('accesskey', gDetachLabelAccesskey); 
  1220.       if (!canDetach)
  1221.         menuitementry.setAttribute('disabled', 'true');
  1222.       menuitementry = openpopup.appendChild(menuitementry);
  1223.  
  1224.       menuitementry = document.createElement('menuitem');
  1225.       menuitementry.attachment = attachment;
  1226.       menuitementry.setAttribute('oncommand', 'this.attachment.deleteAttachment()'); 
  1227.       menuitementry.setAttribute('label', gDeleteLabel); 
  1228.       menuitementry.setAttribute('accesskey', gDeleteLabelAccesskey); 
  1229.       if (!canDetach)
  1230.         menuitementry.setAttribute('disabled', 'true');
  1231.       menuitementry = openpopup.appendChild(menuitementry);
  1232.     }  // if we created a menu item for this attachment...
  1233.   } // if we have a popup
  1234. } 
  1235.  
  1236. function HandleMultipleAttachments(commandPrefix, selectedAttachments)
  1237. {
  1238.  try 
  1239.  {
  1240.    // convert our attachment data into some c++ friendly structs
  1241.    var attachmentContentTypeArray = new Array();
  1242.    var attachmentUrlArray = new Array();
  1243.    var attachmentDisplayNameArray = new Array();
  1244.    var attachmentMessageUriArray = new Array();
  1245.  
  1246.    // populate these arrays..
  1247.    for (index in selectedAttachments)
  1248.    {
  1249.      var attachment = selectedAttachments[index].attachment;
  1250.      attachmentContentTypeArray[index] = attachment.contentType;
  1251.      attachmentUrlArray[index] = attachment.url;
  1252.      attachmentDisplayNameArray[index] = encodeURI(attachment.displayName);
  1253.      attachmentMessageUriArray[index] = attachment.uri;
  1254.    }
  1255.  
  1256.    // okay the list has been built...now call our action code...
  1257.    switch (commandPrefix)
  1258.    {
  1259.      case "saveAttachment":
  1260.        messenger.saveAllAttachments(attachmentContentTypeArray.length,
  1261.                                     attachmentContentTypeArray,
  1262.                                     attachmentUrlArray,
  1263.                                     attachmentDisplayNameArray,
  1264.                                     attachmentMessageUriArray);
  1265.        break;
  1266.      case "detachAttachment":
  1267.        messenger.detachAllAttachments(attachmentContentTypeArray.length,
  1268.                                       attachmentContentTypeArray,
  1269.                                       attachmentUrlArray,
  1270.                                       attachmentDisplayNameArray,
  1271.                                       attachmentMessageUriArray,
  1272.                                       true /* save */);
  1273.        break;
  1274.      case "deleteAttachment":
  1275.        messenger.detachAllAttachments(attachmentContentTypeArray.length,
  1276.                                       attachmentContentTypeArray,
  1277.                                       attachmentUrlArray,
  1278.                                       attachmentDisplayNameArray,
  1279.                                       attachmentMessageUriArray,
  1280.                                       false /* don't save */);
  1281.        break;
  1282.      default:
  1283.        dump (commandPrefix + "** unknown handle all attachments action **\n");
  1284.    }
  1285.  }
  1286.  catch (ex)
  1287.  {
  1288.    dump ("** failed to handle all attachments **\n");
  1289.  }
  1290. }
  1291.  
  1292. function ClearAttachmentList() 
  1293. { 
  1294.   // we also have to disable the File/Attachments menuitem
  1295.   node = document.getElementById("fileAttachmentMenu");
  1296.   if (node)
  1297.     node.setAttribute("disabled", "true");
  1298.  
  1299.   // clear selection
  1300.   var list = document.getElementById('attachmentList');
  1301.   list.clearSelection();
  1302.  
  1303.   while (list.hasChildNodes()) 
  1304.     list.removeChild(list.lastChild);
  1305. }
  1306.  
  1307. function ShowEditMessageButton() 
  1308. {
  1309.   var editBox = document.getElementById("editMessageBox");
  1310.   if (editBox)
  1311.     editBox.collapsed = false;
  1312. } 
  1313.  
  1314. function ClearEditMessageButton() 
  1315. { 
  1316.   var editBox = document.getElementById("editMessageBox");
  1317.   if (editBox)
  1318.     editBox.collapsed = true;
  1319. }
  1320.  
  1321.  
  1322. var attachmentAreaDNDObserver = {
  1323.   onDragStart: function (aEvent, aAttachmentData, aDragAction)
  1324.   {
  1325.     var target = aEvent.target;
  1326.     if (target.localName == "listitem")
  1327.     {
  1328.       var attachmentUrl = target.getAttribute("attachmentUrl");
  1329.       var attachmentDisplayName = target.getAttribute("label");
  1330.       var attachmentContentType = target.getAttribute("attachmentContentType");
  1331.       var tmpurl = attachmentUrl;
  1332.       var tmpurlWithExtraInfo = tmpurl + "&type=" + attachmentContentType + "&filename=" + attachmentDisplayName;
  1333.       aAttachmentData.data = new TransferData();
  1334.       if (attachmentUrl && attachmentDisplayName)
  1335.       {
  1336.         aAttachmentData.data.addDataForFlavour("text/x-moz-url", tmpurlWithExtraInfo + "\n" + attachmentDisplayName);
  1337.         aAttachmentData.data.addDataForFlavour("text/x-moz-url-data", tmpurl);
  1338.         aAttachmentData.data.addDataForFlavour("text/x-moz-url-desc", attachmentDisplayName);
  1339.         
  1340.         aAttachmentData.data.addDataForFlavour("application/x-moz-file-promise-url", tmpurl);   
  1341.         aAttachmentData.data.addDataForFlavour("application/x-moz-file-promise", new nsFlavorDataProvider(), 0, Components.interfaces.nsISupports);     
  1342.       }
  1343.     }
  1344.   }
  1345. };
  1346.  
  1347. function nsFlavorDataProvider()
  1348. {
  1349. }
  1350.  
  1351. nsFlavorDataProvider.prototype =
  1352. {
  1353.   QueryInterface : function(iid)
  1354.   {
  1355.       if (iid.equals(Components.interfaces.nsIFlavorDataProvider) ||
  1356.           iid.equals(Components.interfaces.nsISupports))
  1357.         return this;
  1358.       throw Components.results.NS_NOINTERFACE;
  1359.   },
  1360.   
  1361.   getFlavorData : function(aTransferable, aFlavor, aData, aDataLen)
  1362.   {
  1363.  
  1364.     // get the url for the attachment
  1365.     if (aFlavor == "application/x-moz-file-promise")
  1366.     {
  1367.       var urlPrimitive = { };
  1368.       var dataSize = { };
  1369.       aTransferable.getTransferData("application/x-moz-file-promise-url", urlPrimitive, dataSize);
  1370.  
  1371.       var srcUrlPrimitive = urlPrimitive.value.QueryInterface(Components.interfaces.nsISupportsString);
  1372.  
  1373.       // now get the destination file location from kFilePromiseDirectoryMime
  1374.       var dirPrimitive = {};
  1375.       aTransferable.getTransferData("application/x-moz-file-promise-dir", dirPrimitive, dataSize);
  1376.       var destDirectory = dirPrimitive.value.QueryInterface(Components.interfaces.nsILocalFile);
  1377.  
  1378.       // now save the attachment to the specified location
  1379.       // XXX: we need more information than just the attachment url to save it, fortunately, we have an array
  1380.       // of all the current attachments so we can cheat and scan through them
  1381.  
  1382.       var attachment = null;
  1383.       for (index in currentAttachments)
  1384.       {
  1385.         attachment = currentAttachments[index];
  1386.         if (attachment.url == srcUrlPrimitive)
  1387.           break;
  1388.       }
  1389.  
  1390.       // call our code for saving attachments
  1391.       if (attachment)
  1392.       {
  1393.         var destFilePath = messenger.saveAttachmentToFolder(attachment.contentType, attachment.url, encodeURIComponent(attachment.displayName), attachment.uri, destDirectory);
  1394.         aData.value = destFilePath.QueryInterface(Components.interfaces.nsISupports);
  1395.         aDataLen.value = 4;
  1396.       }
  1397.     }
  1398.   }
  1399.  
  1400. }
  1401.  
  1402. function nsDummyMsgHeader()
  1403. {
  1404. }
  1405.  
  1406. nsDummyMsgHeader.prototype =
  1407. {
  1408.   mProperties : new Array,
  1409.   getStringProperty : function(property) {return this.mProperties[property];},
  1410.   setStringProperty : function(property, val) {this.mProperties[property] = val;},
  1411.   messageSize : 0,
  1412.   recipients : null,
  1413.   from : null,
  1414.   subject : null,
  1415.   ccList : null,
  1416.   messageId : null,
  1417.   accountKey : "",
  1418.   folder : null
  1419. };
  1420.